package com.kaka.rabbitmq.simple;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * @auther kaka
 * @create 2021-06-10 22:47
 */
public class Producer {

    /**
     * 所有中间件技术都是基于tcp/ip协议基础之上构建新型的协议规范，
     * 只不过rabbitmq遵循的是amqp
     *
     * 1、创建连接工厂
     * 2、创建连接connection
     * 3、通过连接获取通道channel
     * 4、通过通道创建交换机，声明队列，绑定关系，路由key，发送消息，接收消息
     * 5、准备消息内容
     * 6、发送消息给队列queue
     * 7、关闭连接
     * 8、关闭通道
     * @param args
     */
    public static void main(String[] args) {

        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("47.100.41.55");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("admin");
        connectionFactory.setPassword("admin");
        connectionFactory.setVirtualHost("/");

        Connection connection = null;
        Channel channel = null;
        try {
            connection = connectionFactory.newConnection("生产者");
            channel = connection.createChannel();

            String queueName = "第一个队列";
            /**
             * @param1 队列的名称
             * @param2 是否要持久化durable=false，所谓持久化消息是否存盘，如果false，非持久化，true是持久化，非持久化会存盘吗？
             * 会存盘，但是重启服务，会丢失。
             * @param3 排他性，是否是独占
             * @param4 是否自动删除，随着最后一个消费者信息发送完毕以后是否把队列删除
             * @param5 携带附加参数
             */
            channel.queueDeclare(queueName,false,false,false,null);

            String message = "你好，rabbitmq";

            /**
             * @param1 交换机
             * @param2 队列，路由key
             * @param3 消息的状态机制
             * @param4 消息主题
             *
             * 面试题：可以存在没有交换机的队列吗？不可能，虽然没有指定交换机但是一定会有一个默认的交换机
             */
            channel.basicPublish("",queueName,null,message.getBytes());

            System.out.println("消息发送成功");
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            if(channel != null && channel.isOpen()){
                try {
                    channel.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            if(connection != null && connection.isOpen()){
                try {
                    connection.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
